package com.yuncheng.spcyApi.utils;

import cn.hutool.core.collection.CollectionUtil;
import com.google.common.base.Strings;
import org.apache.commons.lang3.StringUtils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.sql.Clob;
import java.sql.SQLException;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.lang.Character.UnicodeBlock.*;

/**
 * 字符串处理工具类
 */
public class StringPatternUtils {

    /**
     * 去除多余字符串中的[,] 并取字符中的第一个字符串
     */
    public static String cutFirstComma(String s){
        if (StringUtils.isBlank(s)){
            return "";
        }

        if (s.contains(",")){
            return s.split(",")[0];

        }

        return s;
    }

    /**
     * 参数转码
     */
    public static String encode(String jsonParam){
        try {
            return  URLEncoder.encode(jsonParam, StandardCharsets.UTF_8.name());
        } catch (UnsupportedEncodingException e) {
            return jsonParam;
        }
    }

    /**
     * 截取字符串中字符的第一个之后内容
     */
    public static String indexStringWithChar(String s, char gjz){
        int index = s.indexOf(gjz);
        if (index != -1) {
            return s.substring(index + 1);
        }else {
            return s;
        }
    }

    /**
     * 截取字符串中字符的第一个之前内容
     */
    public static String indexFirstStringWithChar(String s, char gjz){
        int index = s.indexOf(gjz);
        if (index != -1) {
            return s.substring(0, index);
        }else {
            return s;
        }
    }

    /**
     * /, \, :, *, ?, ", <, >, |
     */
    public static String isValidFileName(String fileName){

        String errorMsg = "/ \\ : * ? \" < > | . ";
        String INVALID_CHARS = "/\\:*?\"<>|.";

        for (int i = 0; i < fileName.length(); i++) {
            char c = fileName.charAt(i);
            if (INVALID_CHARS.indexOf(c) != -1) {
                return errorMsg; // 如果找到无效字符，则返回false
            }
        }

        return ""; // 如果没有找到无效字符，则返回true
    }

    /**
     * 判断字符是否为0，为0默认为空
     * @param input
     * @return
     */
    public static String emptyZeroByString(String input){
        if (StringUtils.isBlank(input)){
            return "";
        }

        if (new BigDecimal(input).compareTo(BigDecimal.ZERO) == 0){
            return "";
        }else {
            return input;
        }
    }

    /**
     * 去掉字符串中关键字及前缀
     * @param input
     * @param substring 关键字
     * @return
     */
    public static String removeSubstringWithSurroundingSlashes(String input, String substring) {
        // 使用正则表达式查找以'/'开头，后面跟着substring，然后是'/'的序列，并替换为''（空字符串）
        // 注意：这里假设substring不包含正则表达式的特殊字符，如果包含，需要适当转义
        try {
            if (StringUtils.substring(input, 0, 1).equals("/")){
                return input.replaceFirst(String.format("/(%s)/", Pattern.quote(substring)), "/"); // 注意这里用"/"替换了匹配的部分，因为只有一个斜杠
            }
            return input.replaceFirst(String.format("(%s)/", Pattern.quote(substring)), "/"); // 注意这里用"/"替换了匹配的部分，因为只有一个斜杠
        }catch (Exception e){
            return input;
        }
    }


    /**
     * 获取字符串路径文件后缀
     * @param fileName
     * @return
     */
    public static String getStringFileHz(String fileName){
        if (StringUtils.isBlank(fileName)){
            return "";
        }

        String fileTyle = "";
        try {
            fileTyle = fileName.substring(fileName.lastIndexOf("."),fileName.length());
        }catch (Exception e){
            return fileName;
        }

        return fileTyle;
    }

    /**
     * 文件路径后缀修改为小写
     * */
    public static String stringHzLowerCase(String filePath){
        try {
            int dotIndex = filePath.lastIndexOf('.');
            if (dotIndex != -1) {
                // 提取后缀并转为小写
                String extension = filePath.substring(dotIndex).toLowerCase();
                // 拼接文件路径（不包含后缀部分）和小写的后缀
                String newFilePath = filePath.substring(0, dotIndex) + extension;

                return newFilePath;
            } else {
                return filePath;
            }

        }catch (Exception e){
            return filePath;
        }
    }

    /**
     * 判断字符串中是否为纯数字
     */
    public static boolean verifyCsz(String str){
        boolean result = str.matches("[0-9]+");
        if (result == true) {
            return true;
        }else{
            return false;
        }
    }

    /**
     * 取字符串中，两个字符之间的字符
     * @param str 目标字符串
     * @param startChar 第一个字符
     * @param endChar 第二个字符
     * @return
     */
    public static String getStringBetweenTwoChars(String str, char startChar, char endChar) {
        String regex = startChar + "([^" + endChar + "]*)" + endChar;
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        if (matcher.find()) {
            return matcher.group(1);
        }
        return "";
    }

    /** 根据逗号拼接字符串，获取数组 */
    public static List<String> getListByIds(String ids){
        if (StringUtils.isBlank(ids)){
            return new ArrayList<>(1);
        }
        return Arrays.asList(ids.split(",|，"));
    }

    /**
     * 根据逗号拼接字符串，获取数组
     * */
    public static List<String> getListBySplitRegex(String ids, String regex){
        if (StringUtils.isBlank(ids)){
            return new ArrayList<>();
        }

        /** 存在对应的分割字符，不存在 */
        if (ids.contains(regex)){
            return Arrays.asList(ids.split(regex));

        }else {
            return CollectionUtil.newArrayList(ids);
        }
    }

    /** 根据逗号拼接字符串，获取数组 */
    public static String[] getStringsByIds(String ids){

         return ids.split(",|，");
    }

    /**
     * 将List<String>转为","拼接的字符串
     * */
    public static String convertListToDhString(List<String> idsList){
        if (CollectionUtil.isEmpty(idsList)){
            return "";
        }
        return String.join(",", idsList);
    }

    /**
     * 将字符串的第一个字符变大写
     * @param str 目标字符串
     * @return
     */
    public static String getStringWithFirstUpperCase(String str){
        return str.substring(0,1).toUpperCase() + str.substring(1);
    }

    /**
     * 判断一个字符串中，存在几个某个字符
     * @param orgString 原字符串
     * @param mbChar 查询字符 （'*'）
     */
    public static int getCharCountWithString(String orgString, char mbChar){
        int count = 0;

        if (StringUtils.isBlank(orgString)){
            return count;
        }

        for (int i = 0; i < orgString.length(); i++){
            if (orgString.charAt(i) == mbChar){
                count++;
            }
        }

        return count;
    }

    /**
     * 获取字符串里面的数字
     */
    public static List<Integer> getNumbersInsideByString(String charList){
        List<Integer> numList = new ArrayList<>();
        if (StringUtils.isBlank(charList)){
            return numList;
        }

        String integer = ""; //作为数字字符串的预备区
        for (int i = 0; i < charList.length(); i++) {
            //遍历字符串中每个字符时，若该字符为数字字符，则存入预备区
            if (Character.isDigit(charList.charAt(i))) {
                integer += charList.charAt(i);

                //避免字符串最后一位为数字而遗漏收集的情况
                if (i == charList.length() - 1) {
                    numList.add(Integer.parseInt(integer));
                }
            }else if (!integer.isEmpty()) { //读取到非数字字符，并且检查预备区是否为空
                numList.add(Integer.parseInt(integer));
                integer = "";
            }
        }

        return numList;
    }

    /** 字符串去空-包含全角空格、半角空格 */
    public static String trimString(String str){
        String resultString = "";
        // 去掉全角空格
        if (StringUtils.isNotBlank(str)) {
            resultString = str.replaceAll("\\s*", "");

            resultString = resultString.replaceAll((char)12288+"","");
        }

        return resultString;
    }

    /**
     * 截取字符串后四位
     */
    public static String subStringLastFourDigit(String str){
        if (StringUtils.isBlank(str)){
            return "";
        }

        if (str.length()<5){
            return str;
        }

        String last = str.substring(str.length() - 4);

        return last;
    }

    /**
     * StringBuffer判空
     * @param str
     * @return true为空/false不为空
     */
    public static boolean verifryIsEmptyStringBuffer(StringBuffer str){
        // 不为空情况
        if (str != null && str.length() > 0){
            return false;
        }

        return true;
    }

    /**
     * StringBuilder 判空
     * @param str
     * @return true为空/false不为空
     */
    public static boolean verifryIsEmptyStringBuilder(StringBuilder str){
        // 不为空情况
        if (str != null && str.length() > 0){
            return false;
        }

        return true;
    }

    /** 验证是否存在中文
     * @return true: 存在中文
     * */
    public static boolean checkStringContainChinese(String checkStr){
        if(!Strings.isNullOrEmpty(checkStr)){
            char[] checkChars = checkStr.toCharArray();
            for(int i = 0; i < checkChars.length; i++){
                char checkChar = checkChars[i];
                if(checkCharContainChinese(checkChar)){
                    return true;
                }
            }
        }
        return false;
    }

    /** 验证是否存在中文 */
    private static boolean checkCharContainChinese(char checkChar){
        Character.UnicodeBlock ub = Character.UnicodeBlock.of(checkChar);
        if(CJK_UNIFIED_IDEOGRAPHS == ub || CJK_COMPATIBILITY_IDEOGRAPHS == ub || CJK_COMPATIBILITY_FORMS == ub ||
                CJK_RADICALS_SUPPLEMENT == ub || CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A == ub || CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B == ub){
            return true;
        }
        return false;
    }

    /**
     * 将Clob转 string（大文本转字符串）
     * @param clob
     * @return
     * @throws SQLException
     * @throws IOException
     */
    public static String ClobToString(Clob clob) throws SQLException, IOException {
        String ret = "";
        Reader read= clob.getCharacterStream();
        BufferedReader br = new BufferedReader(read);
        String s = br.readLine();
        StringBuffer sb = new StringBuffer();
        while (s != null) {
            sb.append(s);
            s = br.readLine();
        }
        ret = sb.toString();
        if(br != null){
            br.close();
        }
        if(read != null){
            read.close();
        }
        return ret;
    }

    public static void main(String[] args) {
        List<Integer> numbersInsideByString = StringPatternUtils.getNumbersInsideByString("*01703");
        for (Integer c : numbersInsideByString){
            System.out.println(c);
        }
    }

    /**
     * 百分比计算
     * @param dividend 被除数
     * @param divisor 除数
     * */
    public static String CalculatePpercentage(int dividend, int divisor){
        String attendance = "0";
        if (dividend == 0){
            attendance = "0";

        }else if (divisor == 0){
            attendance = "0";

        }else {
            NumberFormat numberFormat = NumberFormat.getInstance(); // 创建一个数值格式化对象
            numberFormat.setMaximumFractionDigits(2); // 设置精确到小数点后2位
            String format = numberFormat.format((float) dividend / (float) divisor * 100); // 百分比
            if (org.apache.commons.lang3.StringUtils.isNotEmpty(format)){
                attendance = format;
            }
        }
        return attendance;
    }



}
